H-Termination proof of /home/matraf/haskell/eval_FullyBlown

MAYBE 1.619 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/empty.hs
H-Termination of the given Haskell-Program with start terms could not be shown:

↳ HASKELL

  ↳ LR

mainModule Main

((mapM :: (b -> [a]) -> [b] -> [[a]]) :: (b -> [a]) -> [b] -> [[a]])

module Main where

import qualified Prelude

Lambda Reductions:
The following Lambda expression

\xs→return (x : xs)

is transformed to

sequence0 x xs = return (x : xs)

The following Lambda expression

\x→sequence cs >>= sequence0 x

is transformed to

sequence1 cs x = sequence cs >>= sequence0 x

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

mainModule Main

((mapM :: (b -> [a]) -> [b] -> [[a]]) :: (b -> [a]) -> [b] -> [[a]])

module Main where

import qualified Prelude

Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

mainModule Main

((mapM :: (a -> [b]) -> [a] -> [[b]]) :: (a -> [b]) -> [a] -> [[b]])

module Main where

import qualified Prelude

Cond Reductions:
The following Function with conditions

undefined

| False

= undefined

is transformed to

undefined = undefined1

undefined0 True = undefined

undefined1 = undefined0 False

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ Narrow

              ↳ Narrow

mainModule Main

(mapM :: (b -> [a]) -> [b] -> [[a]])

module Main where

import qualified Prelude

Haskell To QDPs

digraph dp_graph {
node [outthreshold=100, inthreshold=100];1[label="mapM",fontsize=16,color="grey",shape="box"];1 -> 3[label="",style="dashed", color="grey", weight=3];
3[label="mapM vx3",fontsize=16,color="grey",shape="box"];3 -> 4[label="",style="dashed", color="grey", weight=3];
4[label="mapM vx3 vx4",fontsize=16,color="black",shape="triangle"];4 -> 5[label="",style="solid", color="black", weight=3];
5[label="sequence . map vx3",fontsize=16,color="black",shape="box"];5 -> 6[label="",style="solid", color="black", weight=3];
6[label="sequence (map vx3 vx4)",fontsize=16,color="burlywood",shape="triangle"];57[label="vx4/vx40 : vx41",fontsize=10,color="white",style="solid",shape="box"];6 -> 57[label="",style="solid", color="burlywood", weight=9];
57 -> 7[label="",style="solid", color="burlywood", weight=3];
58[label="vx4/[]",fontsize=10,color="white",style="solid",shape="box"];6 -> 58[label="",style="solid", color="burlywood", weight=9];
58 -> 8[label="",style="solid", color="burlywood", weight=3];
7[label="sequence (map vx3 (vx40 : vx41))",fontsize=16,color="black",shape="box"];7 -> 9[label="",style="solid", color="black", weight=3];
8[label="sequence (map vx3 [])",fontsize=16,color="black",shape="box"];8 -> 10[label="",style="solid", color="black", weight=3];
9[label="sequence (vx3 vx40 : map vx3 vx41)",fontsize=16,color="black",shape="box"];9 -> 11[label="",style="solid", color="black", weight=3];
10[label="sequence []",fontsize=16,color="black",shape="box"];10 -> 12[label="",style="solid", color="black", weight=3];
11 -> 13[label="",style="dashed", color="red", weight=0];
11[label="vx3 vx40 >>= sequence1 (map vx3 vx41)",fontsize=16,color="magenta"];11 -> 14[label="",style="dashed", color="magenta", weight=3];
12[label="return []",fontsize=16,color="black",shape="box"];12 -> 15[label="",style="solid", color="black", weight=3];
14[label="vx3 vx40",fontsize=16,color="green",shape="box"];14 -> 19[label="",style="dashed", color="green", weight=3];
13[label="vx5 >>= sequence1 (map vx3 vx41)",fontsize=16,color="burlywood",shape="triangle"];60[label="vx5/vx50 : vx51",fontsize=10,color="white",style="solid",shape="box"];13 -> 60[label="",style="solid", color="burlywood", weight=9];
60 -> 17[label="",style="solid", color="burlywood", weight=3];
61[label="vx5/[]",fontsize=10,color="white",style="solid",shape="box"];13 -> 61[label="",style="solid", color="burlywood", weight=9];
61 -> 18[label="",style="solid", color="burlywood", weight=3];
15[label="[] : []",fontsize=16,color="green",shape="box"];19[label="vx40",fontsize=16,color="green",shape="box"];17[label="vx50 : vx51 >>= sequence1 (map vx3 vx41)",fontsize=16,color="black",shape="box"];17 -> 20[label="",style="solid", color="black", weight=3];
18[label="[] >>= sequence1 (map vx3 vx41)",fontsize=16,color="black",shape="box"];18 -> 21[label="",style="solid", color="black", weight=3];
20 -> 22[label="",style="dashed", color="red", weight=0];
20[label="sequence1 (map vx3 vx41) vx50 ++ (vx51 >>= sequence1 (map vx3 vx41))",fontsize=16,color="magenta"];20 -> 23[label="",style="dashed", color="magenta", weight=3];
21[label="[]",fontsize=16,color="green",shape="box"];23 -> 13[label="",style="dashed", color="red", weight=0];
23[label="vx51 >>= sequence1 (map vx3 vx41)",fontsize=16,color="magenta"];23 -> 24[label="",style="dashed", color="magenta", weight=3];
22[label="sequence1 (map vx3 vx41) vx50 ++ vx6",fontsize=16,color="black",shape="triangle"];22 -> 25[label="",style="solid", color="black", weight=3];
24[label="vx51",fontsize=16,color="green",shape="box"];25 -> 26[label="",style="dashed", color="red", weight=0];
25[label="(sequence (map vx3 vx41) >>= sequence0 vx50) ++ vx6",fontsize=16,color="magenta"];25 -> 27[label="",style="dashed", color="magenta", weight=3];
27 -> 6[label="",style="dashed", color="red", weight=0];
27[label="sequence (map vx3 vx41)",fontsize=16,color="magenta"];27 -> 28[label="",style="dashed", color="magenta", weight=3];
26[label="(vx7 >>= sequence0 vx50) ++ vx6",fontsize=16,color="burlywood",shape="triangle"];66[label="vx7/vx70 : vx71",fontsize=10,color="white",style="solid",shape="box"];26 -> 66[label="",style="solid", color="burlywood", weight=9];
66 -> 29[label="",style="solid", color="burlywood", weight=3];
67[label="vx7/[]",fontsize=10,color="white",style="solid",shape="box"];26 -> 67[label="",style="solid", color="burlywood", weight=9];
67 -> 30[label="",style="solid", color="burlywood", weight=3];
28[label="vx41",fontsize=16,color="green",shape="box"];29[label="(vx70 : vx71 >>= sequence0 vx50) ++ vx6",fontsize=16,color="black",shape="box"];29 -> 31[label="",style="solid", color="black", weight=3];
30[label="([] >>= sequence0 vx50) ++ vx6",fontsize=16,color="black",shape="box"];30 -> 32[label="",style="solid", color="black", weight=3];
31[label="(sequence0 vx50 vx70 ++ (vx71 >>= sequence0 vx50)) ++ vx6",fontsize=16,color="black",shape="box"];31 -> 33[label="",style="solid", color="black", weight=3];
32[label="[] ++ vx6",fontsize=16,color="black",shape="triangle"];32 -> 34[label="",style="solid", color="black", weight=3];
33[label="(return (vx50 : vx70) ++ (vx71 >>= sequence0 vx50)) ++ vx6",fontsize=16,color="black",shape="box"];33 -> 35[label="",style="solid", color="black", weight=3];
34[label="vx6",fontsize=16,color="green",shape="box"];35[label="(((vx50 : vx70) : []) ++ (vx71 >>= sequence0 vx50)) ++ vx6",fontsize=16,color="black",shape="box"];35 -> 36[label="",style="solid", color="black", weight=3];
36 -> 37[label="",style="dashed", color="red", weight=0];
36[label="((vx50 : vx70) : [] ++ (vx71 >>= sequence0 vx50)) ++ vx6",fontsize=16,color="magenta"];36 -> 38[label="",style="dashed", color="magenta", weight=3];
38 -> 32[label="",style="dashed", color="red", weight=0];
38[label="[] ++ (vx71 >>= sequence0 vx50)",fontsize=16,color="magenta"];38 -> 39[label="",style="dashed", color="magenta", weight=3];
37[label="((vx50 : vx70) : vx8) ++ vx6",fontsize=16,color="black",shape="triangle"];37 -> 40[label="",style="solid", color="black", weight=3];
39[label="vx71 >>= sequence0 vx50",fontsize=16,color="burlywood",shape="triangle"];70[label="vx71/vx710 : vx711",fontsize=10,color="white",style="solid",shape="box"];39 -> 70[label="",style="solid", color="burlywood", weight=9];
70 -> 41[label="",style="solid", color="burlywood", weight=3];
71[label="vx71/[]",fontsize=10,color="white",style="solid",shape="box"];39 -> 71[label="",style="solid", color="burlywood", weight=9];
71 -> 42[label="",style="solid", color="burlywood", weight=3];
40[label="(vx50 : vx70) : vx8 ++ vx6",fontsize=16,color="green",shape="box"];40 -> 43[label="",style="dashed", color="green", weight=3];
41[label="vx710 : vx711 >>= sequence0 vx50",fontsize=16,color="black",shape="box"];41 -> 44[label="",style="solid", color="black", weight=3];
42[label="[] >>= sequence0 vx50",fontsize=16,color="black",shape="box"];42 -> 45[label="",style="solid", color="black", weight=3];
43[label="vx8 ++ vx6",fontsize=16,color="burlywood",shape="triangle"];72[label="vx8/vx80 : vx81",fontsize=10,color="white",style="solid",shape="box"];43 -> 72[label="",style="solid", color="burlywood", weight=9];
72 -> 46[label="",style="solid", color="burlywood", weight=3];
73[label="vx8/[]",fontsize=10,color="white",style="solid",shape="box"];43 -> 73[label="",style="solid", color="burlywood", weight=9];
73 -> 47[label="",style="solid", color="burlywood", weight=3];
44 -> 43[label="",style="dashed", color="red", weight=0];
44[label="sequence0 vx50 vx710 ++ (vx711 >>= sequence0 vx50)",fontsize=16,color="magenta"];44 -> 48[label="",style="dashed", color="magenta", weight=3];
44 -> 49[label="",style="dashed", color="magenta", weight=3];
45[label="[]",fontsize=16,color="green",shape="box"];46[label="(vx80 : vx81) ++ vx6",fontsize=16,color="black",shape="box"];46 -> 50[label="",style="solid", color="black", weight=3];
47[label="[] ++ vx6",fontsize=16,color="black",shape="box"];47 -> 51[label="",style="solid", color="black", weight=3];
48 -> 39[label="",style="dashed", color="red", weight=0];
48[label="vx711 >>= sequence0 vx50",fontsize=16,color="magenta"];48 -> 52[label="",style="dashed", color="magenta", weight=3];
49[label="sequence0 vx50 vx710",fontsize=16,color="black",shape="box"];49 -> 53[label="",style="solid", color="black", weight=3];
50[label="vx80 : vx81 ++ vx6",fontsize=16,color="green",shape="box"];50 -> 54[label="",style="dashed", color="green", weight=3];
51[label="vx6",fontsize=16,color="green",shape="box"];52[label="vx711",fontsize=16,color="green",shape="box"];53[label="return (vx50 : vx710)",fontsize=16,color="black",shape="box"];53 -> 55[label="",style="solid", color="black", weight=3];
54 -> 43[label="",style="dashed", color="red", weight=0];
54[label="vx81 ++ vx6",fontsize=16,color="magenta"];54 -> 56[label="",style="dashed", color="magenta", weight=3];
55[label="(vx50 : vx710) : []",fontsize=16,color="green",shape="box"];56[label="vx81",fontsize=16,color="green",shape="box"];}

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                    ↳ QDPSizeChangeProof

                  ↳ QDP

                  ↳ QDP

              ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_psPs(:(vx80, vx81), vx6, ba) → new_psPs(vx81, vx6, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

new_psPs(:(vx80, vx81), vx6, ba) → new_psPs(vx81, vx6, ba)
The graph contains the following edges 1 > 1, 2 >= 2, 3 >= 3

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                  ↳ QDP

                    ↳ QDPSizeChangeProof

                  ↳ QDP

              ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_gtGtEs(:(vx710, vx711), vx50, ba) → new_gtGtEs(vx711, vx50, ba)

From the DPs we obtained the following set of size-change graphs:

new_gtGtEs(:(vx710, vx711), vx50, ba) → new_gtGtEs(vx711, vx50, ba)
The graph contains the following edges 1 > 1, 2 >= 2, 3 >= 3

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                  ↳ QDP

                  ↳ QDP

                    ↳ UsableRulesProof

              ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_psPs0(vx3, vx41, ba, bb) → new_sequence(vx3, vx41, ba, bb)
new_sequence(vx3, :(vx40, vx41), ba, bb) → new_gtGtEs0(vx3, vx41, ba, bb)
new_gtGtEs0(vx3, vx41, ba, bb) → new_psPs0(vx3, vx41, ba, bb)
new_gtGtEs0(vx3, vx41, ba, bb) → new_gtGtEs0(vx3, vx41, ba, bb)

The TRS R consists of the following rules:

new_gtGtEs1(:(vx50, vx51), vx3, vx41, ba, bb) → new_psPs5(vx3, vx41, vx50, new_gtGtEs1(vx51, vx3, vx41, ba, bb), ba, bb)
new_psPs4([], vx6, ba) → vx6
new_psPs5(vx3, vx41, vx50, vx6, ba, bb) → new_psPs2(new_sequence0(vx3, vx41, ba, bb), vx50, vx6, ba)
new_psPs2([], vx50, vx6, ba) → new_psPs1(vx6, ba)
new_gtGtEs1([], vx3, vx41, ba, bb) → []
new_psPs1(vx6, ba) → vx6
new_gtGtEs2([], vx50, ba) → []
new_psPs2(:(vx70, vx71), vx50, vx6, ba) → new_psPs3(vx50, vx70, new_psPs1(new_gtGtEs2(vx71, vx50, ba), ba), vx6, ba)
new_gtGtEs2(:(vx710, vx711), vx50, ba) → new_psPs4(:(:(vx50, vx710), []), new_gtGtEs2(vx711, vx50, ba), ba)
new_psPs3(vx50, vx70, vx8, vx6, ba) → :(:(vx50, vx70), new_psPs4(vx8, vx6, ba))
new_psPs4(:(vx80, vx81), vx6, ba) → :(vx80, new_psPs4(vx81, vx6, ba))

The set Q consists of the following terms:

new_psPs1(x0, x1)
new_psPs2([], x0, x1, x2)
new_psPs4([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3)
new_psPs3(x0, x1, x2, x3, x4)
new_gtGtEs1(:(x0, x1), x2, x3, x4, x5)
new_gtGtEs2([], x0, x1)
new_gtGtEs1([], x0, x1, x2, x3)
new_psPs4(:(x0, x1), x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_psPs2(:(x0, x1), x2, x3, x4)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                  ↳ QDP

                  ↳ QDP

                    ↳ UsableRulesProof

                      ↳ QDP

                        ↳ QReductionProof

              ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_psPs0(vx3, vx41, ba, bb) → new_sequence(vx3, vx41, ba, bb)
new_sequence(vx3, :(vx40, vx41), ba, bb) → new_gtGtEs0(vx3, vx41, ba, bb)
new_gtGtEs0(vx3, vx41, ba, bb) → new_psPs0(vx3, vx41, ba, bb)
new_gtGtEs0(vx3, vx41, ba, bb) → new_gtGtEs0(vx3, vx41, ba, bb)

R is empty.
The set Q consists of the following terms:

new_psPs1(x0, x1)
new_psPs2([], x0, x1, x2)
new_psPs4([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3)
new_psPs3(x0, x1, x2, x3, x4)
new_gtGtEs1(:(x0, x1), x2, x3, x4, x5)
new_gtGtEs2([], x0, x1)
new_gtGtEs1([], x0, x1, x2, x3)
new_psPs4(:(x0, x1), x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_psPs2(:(x0, x1), x2, x3, x4)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_psPs1(x0, x1)
new_psPs2([], x0, x1, x2)
new_psPs4([], x0, x1)
new_gtGtEs2(:(x0, x1), x2, x3)
new_psPs3(x0, x1, x2, x3, x4)
new_gtGtEs1(:(x0, x1), x2, x3, x4, x5)
new_gtGtEs2([], x0, x1)
new_gtGtEs1([], x0, x1, x2, x3)
new_psPs4(:(x0, x1), x2, x3)
new_psPs5(x0, x1, x2, x3, x4, x5)
new_psPs2(:(x0, x1), x2, x3, x4)

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                  ↳ QDP

                  ↳ QDP

                    ↳ UsableRulesProof

                      ↳ QDP

                        ↳ QReductionProof

                          ↳ QDP

                            ↳ UsableRulesReductionPairsProof

              ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_psPs0(vx3, vx41, ba, bb) → new_sequence(vx3, vx41, ba, bb)
new_sequence(vx3, :(vx40, vx41), ba, bb) → new_gtGtEs0(vx3, vx41, ba, bb)
new_gtGtEs0(vx3, vx41, ba, bb) → new_psPs0(vx3, vx41, ba, bb)
new_gtGtEs0(vx3, vx41, ba, bb) → new_gtGtEs0(vx3, vx41, ba, bb)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the usable rules with reduction pair processor [15] with a polynomial ordering [25], all dependency pairs and the corresponding usable rules [17] can be oriented non-strictly. All non-usable rules are removed, and those dependency pairs and usable rules that have been oriented strictly or contain non-usable symbols in their left-hand side are removed as well.

The following dependency pairs can be deleted:

new_sequence(vx3, :(vx40, vx41), ba, bb) → new_gtGtEs0(vx3, vx41, ba, bb)

No rules are removed from R.

Used ordering: POLO with Polynomial interpretation [25]:

POL(:(x₁, x₂)) = 2 + x₁ + 2·x₂
POL(new_gtGtEs0(x₁, x₂, x₃, x₄)) = 2 + x₁ + 2·x₂ + x₃ + x₄
POL(new_psPs0(x₁, x₂, x₃, x₄)) = 2 + x₁ + x₂ + x₃ + x₄
POL(new_sequence(x₁, x₂, x₃, x₄)) = 2 + x₁ + x₂ + x₃ + x₄

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                  ↳ QDP

                  ↳ QDP

                    ↳ UsableRulesProof

                      ↳ QDP

                        ↳ QReductionProof

                          ↳ QDP

                            ↳ UsableRulesReductionPairsProof

                              ↳ QDP

                                ↳ DependencyGraphProof

              ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_psPs0(vx3, vx41, ba, bb) → new_sequence(vx3, vx41, ba, bb)
new_gtGtEs0(vx3, vx41, ba, bb) → new_psPs0(vx3, vx41, ba, bb)
new_gtGtEs0(vx3, vx41, ba, bb) → new_gtGtEs0(vx3, vx41, ba, bb)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ HASKELL

  ↳ LR

    ↳ HASKELL

      ↳ BR

        ↳ HASKELL

          ↳ COR

            ↳ HASKELL

              ↳ Narrow

                ↳ AND

                  ↳ QDP

                  ↳ QDP

                  ↳ QDP

                    ↳ UsableRulesProof

                      ↳ QDP

                        ↳ QReductionProof

                          ↳ QDP

                            ↳ UsableRulesReductionPairsProof

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ NonTerminationProof

              ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_gtGtEs0(vx3, vx41, ba, bb) → new_gtGtEs0(vx3, vx41, ba, bb)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

new_gtGtEs0(vx3, vx41, ba, bb) → new_gtGtEs0(vx3, vx41, ba, bb)

The TRS R consists of the following rules:none

s = new_gtGtEs0(vx3, vx41, ba, bb) evaluates to t =new_gtGtEs0(vx3, vx41, ba, bb)

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:

Semiunifier: [ ]
Matcher: [ ]

Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from new_gtGtEs0(vx3, vx41, ba, bb) to new_gtGtEs0(vx3, vx41, ba, bb).

Haskell To QDPs